Uploading and Downloading Files Using Firebase Storage

Course: Android App Development

Topic: Uploading and Downloading Files Using Firebase Storage

Course Link: Android App Development Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to Firebase Storage

Firebase Storage, officially known as Cloud Storage for Firebase, is a cloud-based file storage service that allows Android applications to upload, store, manage, and download user-generated content. It is commonly used to store profile pictures, documents, videos, audio files, assignment submissions, and other media files.

Instead of storing every file directly on a mobile device, developers can upload files to a Firebase Storage bucket and access them when needed. This makes it possible for users to access their files from different devices, provided they have the appropriate permissions.

Firebase Storage integrates with Firebase Authentication and Firebase Security Rules to control who can upload, download, or modify files. The Firebase Android SDK also provides asynchronous operations, progress monitoring, and error handling.

Why Is Firebase Storage Useful?

• Stores images, documents, videos, and other supported file types in the cloud.
• Allows users to upload files from an Android device.
• Supports downloading files for offline access or local processing.
• Provides upload and download progress information.
• Integrates with Firebase Authentication.
• Supports metadata such as file name, content type, and size.
• Allows applications to manage files using structured storage paths.
• Works with other Firebase services to build complete applications.

2. Learning Objectives

After studying this topic, learners should be able to:

• Understand Firebase Storage and its role in Android development.
• Create a Firebase project and configure a Storage bucket.
• Add Firebase Storage dependencies to an Android application.
• Select images and documents using Android's file picker.
• Upload files using the Firebase Storage SDK.
• Monitor upload progress and handle failures.
• Generate and retrieve file download URLs.
• Download files to local device storage.
• Understand file metadata and storage references.
• Configure Firebase Storage Security Rules.
• Implement secure file management using Kotlin.
• Test and troubleshoot file upload and download operations.

3. Understanding Cloud Storage Concepts

4. How Firebase Storage Works

Firebase Storage operations generally follow a simple workflow. The Android application selects a file, creates a reference to its intended cloud location, and performs an upload or download request.

File Upload Workflow

User Selects a File
        |
        v
Android File Picker Returns URI
        |
        v
Validate File and User Permissions
        |
        v
Create Firebase Storage Reference
        |
        v
Upload File Using putFile()
        |
        v
Monitor Progress and Handle Result
        |
        v
Retrieve Download URL if Needed

File Download Workflow

User Requests a File
        |
        v
Create Storage Reference
        |
        v
Check Access Permissions
        |
        v
Choose Download Method
        |
        +----------------------+
        |                      |
        v                      v
   getFile()                getBytes()
        |                      |
        v                      v
 Save to Local File       Receive Data in Memory
        |                      |
        +-----------+----------+
                    |
                    v
          Handle Success or Error

Firebase Storage does not automatically make every file publicly accessible. The request must satisfy the applicable Storage Security Rules, and the application must handle failures such as missing files or insufficient permissions.

5. Prerequisites

Before implementing Firebase Storage, ensure that the following requirements are met:

• Android Studio is installed.
• An Android project using Kotlin or Java is available.
• A Google account can access Firebase Console.
• The application has been registered with a Firebase project.
• The application contains the correct Firebase configuration file.
• Firebase Storage has been configured for the project.
• Internet access is available for cloud operations.
• The developer understands basic Android UI development and Kotlin functions.
• Firebase Authentication is configured if files require signed-in users.

6. Creating a Firebase Project

Step 1: Open Firebase Console

Visit Firebase Console and sign in with your Google account.

Step 2: Create or Select a Project

1. Create a new Firebase project or select an existing one.
2. Register the Android application using its application ID.
3. Download the google-services.json configuration file.
4. Place the file in the Android application's app/ directory.

Step 3: Configure Cloud Storage

1. Open the Firebase project.
2. Navigate to the Storage section.
3. Follow the setup instructions to create or initialize the Storage bucket.
4. Select the appropriate project configuration and storage location.
5. Review the applicable plan requirements and billing implications.
6. Configure Storage Security Rules before uploading real user data.

Firebase Storage availability and setup requirements can depend on the project's configuration and current Firebase plan. Follow the instructions displayed in the Firebase Console.

7. Adding Firebase Storage Dependencies

The Firebase Storage SDK provides the classes required to create storage references, upload files, download files, and manage metadata.

Project-Level Gradle Configuration

Ensure that the Google Services plugin is configured with a compatible version in the project-level build.gradle.kts file. A typical configuration is shown below.

// Project-level build.gradle.kts
plugins {
    id("com.google.gms.google-services") version "4.4.4" apply false
}

App-Level Gradle Configuration

Add the Firebase BoM and Storage dependency to the app-level build.gradle.kts file.

// app/build.gradle.kts
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("com.google.gms.google-services")
}

dependencies {
    implementation(platform("com.google.firebase:firebase-bom:34.5.0"))
    implementation("com.google.firebase:firebase-storage")
}

The versions shown are illustrative examples. Verify current compatible versions in the official Firebase documentation and adapt the plugin declarations to your existing Gradle configuration. When using the Firebase BoM, do not normally specify an independent version for each Firebase library.

Synchronize Gradle after adding the dependency.

Official guide: Set up Firebase in an Android project.

8. Initializing Firebase Storage

After configuring Firebase, obtain an instance of FirebaseStorage and create a reference to the desired storage location.

import com.google.firebase.storage.FirebaseStorage
import com.google.firebase.storage.StorageReference

class StorageRepository {

    private val storage =
        FirebaseStorage.getInstance()

    private val rootReference: StorageReference =
        storage.reference

    fun getRootReference(): StorageReference {
        return rootReference
    }
}

FirebaseStorage.getInstance() provides access to the Storage service associated with the configured Firebase application. The root reference represents the root of the configured storage bucket.

9. Understanding Storage References and Paths

A Storage Reference identifies a bucket or a particular object within the bucket. Developers use the child() method to create references to files and folders.

val storage = FirebaseStorage.getInstance()
val rootRef = storage.reference

val imagesRef = rootRef.child("images")
val profileRef = rootRef.child("users/user123/profile.jpg")
val documentsRef = rootRef.child("documents/report.pdf")

These paths organize files logically. Cloud Storage object paths can contain slash-separated segments, but folders are generally virtual prefixes rather than ordinary filesystem directories.

Recommended Storage Structure

Firebase Storage
|
+-- users/
|   +-- USER_UID_123/
|   |   +-- profile.jpg
|   |   +-- documents/
|   |       +-- resume.pdf
|   |
|   +-- USER_UID_456/
|       +-- profile.jpg
|
+-- public-assets/
    +-- app-logo.png

For private user content, using the authenticated user's UID in the object path makes it easier to define rules that restrict access to the owner.

10. Selecting Files in Android

Before uploading a file, an application must obtain access to the file selected by the user. Android's Activity Result APIs provide a convenient way to launch a system file picker.

Opening the Image Picker

The following Kotlin example uses ActivityResultContracts.GetContent to let the user choose an image.

import android.net.Uri
import android.os.Bundle
import android.widget.Button
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity

class UploadActivity : AppCompatActivity() {

    private var selectedFileUri: Uri? = null

    private val imagePicker =
        registerForActivityResult(
            ActivityResultContracts.GetContent()
        ) { uri: Uri? ->
            selectedFileUri = uri

            if (uri != null) {
                // A file was selected.
                // Enable the upload button here.
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Set up the screen layout before accessing its views.
        // Example:
        // findViewById<Button>(R.id.selectImageButton)
        //     .setOnClickListener {
        //         imagePicker.launch("image/*")
        //     }
    }
}

The example demonstrates file selection. Connect the picker to an actual layout and invoke imagePicker.launch("image/*") from the selection button.

Selecting Documents

To select documents such as PDFs, use ActivityResultContracts.OpenDocument or another suitable Android document picker contract.

private val documentPicker =
    registerForActivityResult(
        ActivityResultContracts.OpenDocument()
    ) { uri: Uri? ->
        if (uri != null) {
            // Use the selected document URI.
            // Upload it through Firebase Storage.
        }
    }

// Launch the picker:
// documentPicker.launch(arrayOf("application/pdf"))

The system picker provides access to user-selected files without requiring broad storage access permissions for many common file-selection workflows. Use the appropriate contract and retain URI access only as needed.

11. Uploading Files Using putFile()

The putFile() method uploads a file identified by a local Android Uri. It returns an upload task that can be observed for success, failure, and progress.

Basic Upload Example

import android.net.Uri
import com.google.firebase.storage.FirebaseStorage

fun uploadImage(
    fileUri: Uri,
    onResult: (Boolean, String) -> Unit
) {
    val storage = FirebaseStorage.getInstance()

    val fileName = "image_${System.currentTimeMillis()}.jpg"

    val fileRef = storage.reference
        .child("images/$fileName")

    fileRef.putFile(fileUri)
        .addOnSuccessListener {
            onResult(true, "File uploaded successfully.")
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage
                    ?: "Upload failed."
            )
        }
}

Explanation

• fileUri identifies the selected local file.
• FirebaseStorage.getInstance() obtains the Firebase Storage service.
• child() creates a reference to the destination object path.
• putFile() starts the upload operation.
• addOnSuccessListener() handles successful completion.
• addOnFailureListener() handles errors.

The example assumes the selected file is an image with a suitable JPEG filename and content. In a production application, determine or validate the actual file type instead of blindly assigning a file extension.

12. Uploading Files with Metadata

Metadata describes a stored file and may include its content type, custom attributes, and other properties supported by Cloud Storage.

Specifying the correct MIME type can help other parts of the application handle the uploaded file correctly.

import android.net.Uri
import com.google.firebase.storage.FirebaseStorage
import com.google.firebase.storage.StorageMetadata

fun uploadPdf(
    fileUri: Uri,
    onResult: (Boolean, String) -> Unit
) {
    val storage = FirebaseStorage.getInstance()

    val metadata = StorageMetadata.Builder()
        .setContentType("application/pdf")
        .build()

    val fileRef = storage.reference
        .child("documents/report_${System.currentTimeMillis()}.pdf")

    fileRef.putFile(fileUri, metadata)
        .addOnSuccessListener {
            onResult(true, "PDF uploaded successfully.")
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage ?: "PDF upload failed."
            )
        }
}

Common MIME Types

Never trust a filename or MIME type supplied by a client as proof that a file is safe. Validate file content and enforce suitable restrictions for the application's use case.

13. Monitoring Upload Progress

For larger files, users should know how much data has been uploaded. Firebase Storage provides an upload progress listener that reports the number of bytes transferred and the total byte count.

import android.net.Uri
import com.google.firebase.storage.FirebaseStorage

fun uploadWithProgress(
    fileUri: Uri,
    onProgress: (Int) -> Unit,
    onResult: (Boolean, String) -> Unit
) {
    val storage = FirebaseStorage.getInstance()

    val fileRef = storage.reference
        .child("uploads/file_${System.currentTimeMillis()}")

    fileRef.putFile(fileUri)
        .addOnProgressListener { snapshot ->
            val total = snapshot.totalByteCount

            val progress = if (total > 0L) {
                (
                    snapshot.bytesTransferred * 100L / total
                ).toInt()
            } else {
                0
            }

            onProgress(progress)
        }
        .addOnSuccessListener {
            onProgress(100)
            onResult(true, "Upload completed.")
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage ?: "Upload failed."
            )
        }
}

Displaying Progress in the UI

In a traditional Android layout, use a ProgressBar to display the percentage. In Jetpack Compose, a LinearProgressIndicator can represent the same progress value.

For example, when using a horizontal progress bar, update its progress with the integer value received from the callback. Ensure UI changes are made on the main thread and that callbacks do not update a destroyed screen.

14. Pausing, Resuming, and Cancelling Uploads

Firebase upload tasks support pause, resume, and cancellation operations. These features are useful for applications that upload large videos, documents, or other files over variable network connections.

val uploadTask = FirebaseStorage.getInstance()
    .reference
    .child("uploads/example.bin")
    .putFile(fileUri)

// Pause the upload
uploadTask.pause()

// Resume the upload
uploadTask.resume()

// Cancel the upload
uploadTask.cancel()

This is an illustration of the task controls. In an actual application, retain the active upload task and call these methods in response to the appropriate UI actions.

• Pause: Temporarily stops transferring data.
• Resume: Continues a paused upload where possible.
• Cancel: Stops the task and reports cancellation as a failure.

Task controls do not by themselves guarantee that an upload will continue across application process termination. Long-running workflows may require explicit upload-session handling or an appropriate background-work design.

15. Retrieving a Download URL

After a file has been uploaded, an application may need a URL to display the image, associate the file with a database record, or pass a reference to another component.

The downloadUrl property on a Storage Reference retrieves a download URL when the caller has the required access.

import com.google.firebase.storage.FirebaseStorage

fun getFileDownloadUrl(
    filePath: String,
    onResult: (Boolean, String) -> Unit
) {
    val fileRef = FirebaseStorage.getInstance()
        .reference
        .child(filePath)

    fileRef.downloadUrl
        .addOnSuccessListener { uri ->
            onResult(true, uri.toString())
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage
                    ?: "Unable to retrieve download URL."
            )
        }
}

Important Security Note

A Firebase Storage download URL may contain a token that allows access to the object to anyone who possesses the URL, depending on the URL and access configuration. Treat such URLs as potentially shareable credentials. Do not expose them unintentionally or assume that Storage Security Rules alone will revoke access through every previously issued tokenized URL. For highly sensitive files, carefully evaluate the access model and use an authenticated retrieval approach where appropriate.

16. Downloading Files to Local Storage with getFile()

The getFile() method downloads a file directly to a local file. It is useful when the user needs to save a document for offline use, open a downloaded file, or process it locally.

import java.io.File
import com.google.firebase.storage.FirebaseStorage

fun downloadFile(
    remotePath: String,
    destinationFile: File,
    onResult: (Boolean, String) -> Unit
) {
    val fileRef = FirebaseStorage.getInstance()
        .reference
        .child(remotePath)

    fileRef.getFile(destinationFile)
        .addOnSuccessListener {
            onResult(
                true,
                "File saved to ${destinationFile.absolutePath}"
            )
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage
                    ?: "Download failed."
            )
        }
}

Example Usage

val destination = File(
    context.filesDir,
    "downloaded_report.pdf"
)

downloadFile(
    remotePath = "documents/report.pdf",
    destinationFile = destination
) { success, message ->
    // Update the UI with the result.
}

The example stores the file in the application's internal files directory. This location is generally private to the application. To save a file where users can easily access it through other applications, use an appropriate Android document or media-saving workflow and handle the relevant permissions and platform requirements.

17. Downloading Small Files into Memory

The getBytes() method downloads a file into a byte array. It can be useful for small files that need to be processed directly in memory.

import com.google.firebase.storage.FirebaseStorage

fun downloadSmallFile(
    remotePath: String,
    onResult: (Boolean, ByteArray?) -> Unit
) {
    val fileRef = FirebaseStorage.getInstance()
        .reference
        .child(remotePath)

    val maxDownloadSize = 1024L * 1024L

    fileRef.getBytes(maxDownloadSize)
        .addOnSuccessListener { bytes ->
            onResult(true, bytes)
        }
        .addOnFailureListener {
            onResult(false, null)
        }
}

The maximum size in this example is one mebibyte. Choose a suitable maximum based on the file type and available memory. Do not use an unlimited byte limit for arbitrary files, because loading a large object into memory may cause excessive memory consumption or an application crash.

18. Downloading a File Using Its URL

If an application already has a valid download URL, it may use an HTTP client or a library such as an image-loading library to retrieve the file. For Firebase Storage objects, the SDK's getFile() or getBytes() methods are often convenient because they use the configured Storage reference and Firebase access controls.

For example, a stored image can be displayed through a compatible image-loading library such as Glide when the library is configured to handle the relevant URL or Firebase Storage reference.

// Conceptual example using Glide and a download URL:
Glide.with(imageView)
    .load(downloadUrl)
    .into(imageView)

This snippet assumes that Glide is already configured and that imageView and downloadUrl exist. A URL-based approach should be selected with care when files are private or access must be tightly controlled.

19. Organizing User Files with Firebase Authentication

When an application stores private user files, a common approach is to organize them under the authenticated user's UID.

val user = FirebaseAuth.getInstance().currentUser

if (user != null) {
    val uid = user.uid

    val userFileRef = FirebaseStorage
        .getInstance()
        .reference
        .child("users/$uid/profile.jpg")

    // Upload or download using userFileRef.
}

The UID is useful for organizing files, but using it in a path is not enough to protect the files. Security Rules must independently verify the authenticated user's identity and restrict access to the intended objects.

20. Firebase Storage Security Rules

Storage Security Rules determine whether a request to upload, read, update, or delete a file is permitted. Rules should be designed around the application's data ownership and validation requirements.

Example: Restricting Access to a User's Own Files

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {
    match /users/{userId}/{allPaths=**} {
      allow read, write:
        if request.auth != null
        && request.auth.uid == userId;
    }
  }
}

This example allows an authenticated user to read and write objects under a path containing their own UID. It is a starting point, not a complete production policy. It does not restrict file size or content type, and it grants all supported read and write operations within that user's path.

Adding File Size and Content-Type Restrictions

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {
    match /users/{userId}/images/{fileName} {
      allow read:
        if request.auth != null
        && request.auth.uid == userId;

      allow write:
        if request.auth != null
        && request.auth.uid == userId
        && request.resource != null
        && request.resource.size < 5 * 1024 * 1024
        && request.resource.contentType.matches('image/.*');
    }
  }
}

This illustrative rule restricts writes to authenticated owners and limits uploads to files under five mebibytes with an image MIME type. Production rules should account for object deletion, updates, metadata, trusted content validation, and the application's intended file types. MIME type checks alone cannot prove that a file contains safe image data.

Official reference: Firebase Storage Security Rules.

21. Handling Upload and Download Errors

File operations may fail for several reasons, including network problems, missing files, invalid references, authentication failures, and permission restrictions.

Error-Handling Best Practices

• Always attach appropriate failure handling to asynchronous tasks.
• Show user-friendly error messages rather than raw exception traces.
• Prevent duplicate uploads when a request is already in progress.
• Retry only when appropriate and avoid rapid repeated requests.
• Do not log sensitive download URLs or user files unnecessarily.
• Ensure that UI callbacks respect the Activity or screen lifecycle.
• Use structured logging for diagnostics without exposing private information.

22. File Metadata Management

Firebase Storage supports metadata operations that help applications inspect or update information about stored files.

Retrieving Metadata

import com.google.firebase.storage.FirebaseStorage

fun getFileMetadata(
    remotePath: String,
    onResult: (String) -> Unit
) {
    val fileRef = FirebaseStorage.getInstance()
        .reference
        .child(remotePath)

    fileRef.metadata
        .addOnSuccessListener { metadata ->
            val details = """
                Name: ${metadata.name}
                Size: ${metadata.sizeBytes} bytes
                Content type: ${metadata.contentType}
            """.trimIndent()

            onResult(details)
        }
        .addOnFailureListener { exception ->
            onResult(
                exception.localizedMessage
                    ?: "Could not retrieve metadata."
            )
        }
}

Common Metadata Fields

• name — the object's name.
• sizeBytes — the stored object's size in bytes.
• contentType — the MIME type associated with the object.
• creationTimeMillis — the object's creation time, where available.
• updatedTimeMillis — the object's last update time, where available.
• Custom metadata — application-defined key-value information where appropriate.

Metadata is useful for displaying file details, validating expected properties, and building file-management screens. It should not replace proper file-content validation or authorization.

23. Uploading Multiple Files

Some applications allow users to upload several images or documents in one session. Each file can be uploaded to a separate Storage Reference.

import android.net.Uri
import com.google.firebase.storage.FirebaseStorage

fun uploadMultipleFiles(
    fileUris: List<Uri>,
    onFileResult: (Uri, Boolean) -> Unit
) {
    val rootRef = FirebaseStorage.getInstance().reference

    fileUris.forEachIndexed { index, uri ->
        val destination = rootRef.child(
            "uploads/file_${System.currentTimeMillis()}_$index"
        )

        destination.putFile(uri)
            .addOnSuccessListener {
                onFileResult(uri, true)
            }
            .addOnFailureListener {
                onFileResult(uri, false)
            }
    }
}

This example starts uploads for each selected file. For a production application, consider limiting concurrent transfers, tracking each task separately, validating every file, and providing an overall progress or completion summary.

24. Deleting Files from Firebase Storage

File management may also require deleting old or unwanted files. The delete() method removes an object when the request satisfies the Storage Security Rules.

import com.google.firebase.storage.FirebaseStorage

fun deleteFile(
    remotePath: String,
    onResult: (Boolean, String) -> Unit
) {
    val fileRef = FirebaseStorage.getInstance()
        .reference
        .child(remotePath)

    fileRef.delete()
        .addOnSuccessListener {
            onResult(true, "File deleted successfully.")
        }
        .addOnFailureListener { exception ->
            onResult(
                false,
                exception.localizedMessage ?: "File deletion failed."
            )
        }
}

Only expose delete actions when appropriate. In applications where a database stores file references, coordinate deletion carefully so that the database does not continue to reference a missing object.

25. Integrating Firebase Storage with MVVM Architecture

For a maintainable Android application, file operations should be separated from the screen's presentation logic. Model-View-ViewModel (MVVM) is a common architecture for organizing this code.

Example Repository Interface

import android.net.Uri

interface FileStorageRepository {

    suspend fun uploadFile(
        remotePath: String,
        fileUri: Uri
    ): String

    suspend fun downloadFile(
        remotePath: String,
        destinationPath: String
    )

    suspend fun getDownloadUrl(
        remotePath: String
    ): String
}

A concrete implementation can wrap Firebase tasks in Kotlin coroutines and expose progress through a Flow or another observable mechanism. The ViewModel can then publish loading, progress, success, and failure states without placing storage logic inside an Activity.

Benefits of This Architecture

• Improves code organization.
• Makes file operations easier to test.
• Separates UI logic from cloud-storage operations.
• Supports consistent loading and error states.
• Makes it easier to reuse upload and download functionality across screens.

26. Performance and Cost Considerations

Cloud file operations consume network bandwidth and storage resources. Applications should optimize transfers to improve user experience and control costs.

• Compress images when appropriate before uploading.
• Set reasonable file size limits.
• Avoid repeatedly downloading files that can be cached safely.
• Use direct-to-file downloads for large objects rather than loading everything into memory.
• Display progress indicators for longer operations.
• Use sensible storage paths and naming conventions.
• Remove unnecessary files according to the application's retention policy.
• Review Firebase Storage pricing, quotas, and network-transfer charges for the selected plan.
• Monitor usage and configure appropriate budget alerts where available.
• Test file operations on both Wi-Fi and mobile networks.

27. Testing Firebase Storage

Testing should verify successful transfers, failure scenarios, file integrity, and security restrictions.

Manual Testing Checklist

• Select a valid image and upload it.
• Upload a PDF document with the correct content type.
• Verify that the object appears at the expected path in Firebase Console.
• Monitor upload progress and verify the completion state.
• Retrieve a download URL when required.
• Download the uploaded file and confirm that it can be opened.
• Try uploading a file larger than the configured limit.
• Test behavior when internet connectivity is interrupted.
• Attempt to read another user's private file.
• Verify that unauthorized requests are denied.
• Test deleting an object and handling a missing file.
• Confirm that large files are not unnecessarily loaded into memory.

Using the Firebase Local Emulator Suite

The Firebase Local Emulator Suite can help developers test supported Firebase services in a controlled development environment. Where supported by the current setup, use the Storage emulator to test rules and file operations without relying on production data.

Reference: Firebase Local Emulator Suite documentation.

28. Practical Project: Android File Upload and Download Application

Create an Android application that lets users select files, upload them to Firebase Storage, retrieve their download URLs, and download stored files for offline use.

Project Requirements

• Create a file-selection screen using Android Activity Result APIs.
• Allow users to select images and PDF documents.
• Validate file types and sizes before uploading.
• Upload selected files to Firebase Storage.
• Display upload progress.
• Show success and failure messages.
• Retrieve and display a download URL when needed.
• Download selected files to an appropriate local destination.
• Display file metadata, including size and content type.
• Restrict access to private files using Firebase Authentication and Security Rules.
• Provide an option to delete files when permitted.

Suggested Project Structure

com.example.firebasestorage
|
+-- data
|   +-- FileStorageRepositoryImpl.kt
|
+-- domain
|   +-- FileStorageRepository.kt
|
+-- ui
|   +-- upload
|   |   +-- UploadActivity.kt
|   |   +-- UploadViewModel.kt
|   |
|   +-- downloads
|   |   +-- DownloadActivity.kt
|   |   +-- DownloadViewModel.kt
|   |
|   +-- files
|       +-- FileListActivity.kt
|
+-- MainActivity.kt

This is a suggested structure. You can use Jetpack Compose screens instead of Activities for the UI while keeping the repository and ViewModel responsibilities separate.

Expected Output

• Users can select files from the device.
• Selected files upload to the intended Storage path.
• Upload progress is visible to the user.
• Download operations save files successfully.
• Errors are handled without crashing the application.
• Private files remain protected by the configured security rules.

29. Common Interview Questions and Answers

Q1. What is Firebase Storage?

Firebase Storage is a cloud-based service that allows applications to store and retrieve user-generated files such as images, videos, and documents.

Q2. Which Firebase class provides access to Cloud Storage?

FirebaseStorage provides access to the Storage service and creates Storage References.

Q3. What is the purpose of a Storage Reference?

A Storage Reference represents the root of a bucket or a particular object path within that bucket.

Q4. Which method uploads a local file identified by a URI?

putFile() uploads a local file using an Android URI.

Q5. How can upload progress be monitored?

Use addOnProgressListener() and calculate the percentage from the transferred bytes and total byte count.

Q6. How can a download URL be retrieved?

Use the Storage Reference's downloadUrl property and handle its success or failure result.

Q7. What is the difference between getFile() and getBytes()?

getFile() writes the downloaded content to a local file, while getBytes() loads the content into memory as a byte array.

Q8. What is the purpose of Storage metadata?

Metadata describes an object through properties such as file name, size, content type, and supported custom attributes.

Q9. Why are Firebase Storage Security Rules important?

They control which clients can read, upload, update, or delete stored objects.

Q10. Does Firebase Authentication automatically protect every stored file?

No. Authentication identifies the user, but Storage Security Rules must explicitly define which files that user can access.

Q11. Why should large files not be downloaded using getBytes() without a size limit?

Large byte arrays can consume excessive memory and may cause the application to crash. Direct-to-file or streaming approaches are more appropriate for large downloads.

Q12. Can an application pause or cancel an upload?

Yes. Firebase upload tasks provide methods such as pause(), resume(), and cancel().

30. Practice Exercises

1. Create a Firebase Storage project and connect it to an Android application.
2. Implement an image picker and upload the selected image.
3. Upload a PDF document with its content type set correctly.
4. Display upload progress using a progress bar.
5. Retrieve the download URL for an uploaded file.
6. Download a file into the application's internal storage.
7. Display file metadata in the application UI.
8. Implement upload cancellation.
9. Configure rules so users can access only their own files.
10. Test upload and download failures when the network is unavailable.
11. Create a file list screen with upload, download, and delete options.
12. Separate storage operations into a repository and test the ViewModel.

31. Quick Revision

32. Official Documentation and Learning Resources

• Uploading files with Cloud Storage for Firebase on Android
• Downloading files with Cloud Storage for Firebase on Android
• Firebase Storage Security Rules
• Working with file metadata
• Firebase Local Emulator Suite

33. Conclusion

Uploading and downloading files using Firebase Storage is an important skill in Android application development. Firebase Storage provides convenient APIs for storing images, documents, and other files in the cloud, while supporting progress monitoring, metadata management, and local downloads.

A robust implementation should combine file validation, suitable download methods, lifecycle-aware UI updates, and reliable error handling. Most importantly, Firebase Storage Security Rules must protect private content, and download URLs must be handled carefully because possession of a tokenized URL may permit access to the file.

By completing the practical exercises in these notes, developers can build Android applications that support secure file uploads, downloads, and user-specific file management.

Explore the JustAcademy Android App Development Course to continue learning, visit the JustAcademy website, or register for a course demo.